{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1、用pandas清洗处理数据\n",
    "## 1.1 判断是否存在空值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     True\n",
       "1     True\n",
       "2    False\n",
       "3    False\n",
       "4    False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "s=pd.Series(list(\"Hello\"))\n",
    "s[0]=None\n",
    "s[1]=np.NaN\n",
    "s.isnull()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数据缺失在很多数据中存在，是首先要解决的常见问题。NaN（Not a Number）在NumPy中是浮点值，易检测。而Python的None关键字在数组中也被作为NaN处理。需要注意的是，Python本身并没有定义NaN，而numpy中定义了NaN。因此使用的使用，要明确使用np.NaN。None是在Python中定义的，可以直接使用。Pandas提供isnull和notnull两个方法来判断Series对象或DataFrame对象中是否存在空值。其输出结果是一个有True和False组成的bool类型的Series对象或DataFrame对象。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 过滤空值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>5.0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0    1  2\n",
       "0  1  NaN  3\n",
       "1  4  5.0  6"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame([[1,None,3],[4,5,6]])\n",
    "df2 = df.dropna()\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>5.0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0    1  2\n",
       "1  4  5.0  6"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Series过滤空值时，直接过滤掉空值所在的数据和对应的索引。DataFrame过滤空值时，dropna()默认会删除包含缺失值的行，传入how=‘all’参数时，删除所有值均为NaN的行；\n",
    "传入axis=1，可以按照同样的方式删除列。注意在生成DataFrame时，None默认被标记为float，所以对应的列中，整数5也被转化成5.0。另外，dropna方法返回一个新的DataFrame对象，原来的DataFrame对象不变。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 补全空值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0    1    2\n",
       "0  1  NaN  3.0\n",
       "1  4  5.0  NaN"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame([[1,None,3],[4,5,np.NaN]])\n",
    "df2 = df.fillna(0)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>5.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0    1    2\n",
       "0  1  0.0  3.0\n",
       "1  4  5.0  0.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dropna()简单粗暴，抛弃了其他非空数据，因此可以采取补全数据的方式，如fillna()。补全时，可以使用常数补全，如fillna(0)；或者用字典补全，即为不同的列设置不同的填充值，字典的键就是列的索引名，如fillna({1:0.5, 2:0})。需要注意的是，默认fillna()返回一个新的对象。如果需要在原对象上修改数据，可设定inplace=True修改原对象，如df.fillna(0, inplace=True)。\n",
    "空值补全时可能会污染数据，比如错误的补全值。一般可以使用插值方法来填充，如前向填充：fillna(method=“ffile”, limit=2)，或者将Series的平均值或中位数填充NaN，如data.fillna(data.mean())。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 删除重复值 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>K1</th>\n",
       "      <th>K2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>b</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>b</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  K1  K2\n",
       "0  a   4\n",
       "1  b   5\n",
       "2  b   5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame({\"K1\":['a','b','b'],'K2':[4,5,5]})\n",
    "df2 = df.drop_duplicates()\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>K1</th>\n",
       "      <th>K2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>b</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  K1  K2\n",
       "0  a   4\n",
       "1  b   5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于各种原因，DataFrame中会出现重复的行。可以使用DataFrame的duplicated()用于判断某行是否重复，返回一个Series对象，由True和False构成。可以使用drop_duplicates()直接返回不重复的值，还可以指定特定列，如：drop_duplicates([‘K1’])。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 检测和过滤异常值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>100.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>49.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>29.011492</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>24.750000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>49.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>74.250000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>99.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                0\n",
       "count  100.000000\n",
       "mean    49.500000\n",
       "std     29.011492\n",
       "min      0.000000\n",
       "25%     24.750000\n",
       "50%     49.500000\n",
       "75%     74.250000\n",
       "max     99.000000"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame(np.arange(100))\n",
    "df=df.describe()\n",
    "df2 = df[0][df[0]>50]\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    100.00\n",
       "75%       74.25\n",
       "max       99.00\n",
       "Name: 0, dtype: float64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "异常值（outlier）指的是在正常情况下，不可能产生的数值，比如在正常的水温测试过程中，水温在100摄氏度一下，人的年龄一般在120岁以内，大于零岁。异常值的过滤或变换运算在很大程度上其实就是数组运算。DataFrame的describe方法可以返回该DataFrame对象的数据进行统计信息展示。比如最大最小值，均值等。我们假定超过50的数据为异常值，可以通过使用any方法选出全部满足条件的行，比如any(1)表示一行中有1个数据满足即可进行过滤。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.6 数据排序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>h</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>l</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>l</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>o</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>W</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>o</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>r</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>l</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>d</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    A\n",
       "0   h\n",
       "1   e\n",
       "2   l\n",
       "3   l\n",
       "4   o\n",
       "5    \n",
       "6   W\n",
       "7   o\n",
       "8   r\n",
       "9   l\n",
       "10  d"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "df= pd.DataFrame(list(\"hello World\"),columns=['A'])\n",
    "df2 = df.sort_values('A',ascending=False)[:3]\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>r</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>o</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>o</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A\n",
       "8  r\n",
       "4  o\n",
       "7  o"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sort_index()在指定轴上对索引排序，默认升序，默认0轴（行）。Sort_values()在指定轴上根据数值进行排序，默认升序。如果排序的DataFrame中存在NaN数据，则排序末尾（最大或最小）。此外，Pandas还提供了一个更简单的取前n行最大值的函数：Nlargest()，使用方法为：df.nlargest(3,'A')，即取A列中最大的前3行数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.7 空值替换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     A\n",
       "0  0.0\n",
       "1  NaN\n",
       "2  2.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "df= pd.DataFrame(np.arange(3),columns=['A'])\n",
    "df.iloc[1,0]=-999\n",
    "df.replace(-999,np.NaN,inplace=True)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用fillna填充空值是通用值替换的特殊例子。对于不同的数据源，对空值的标识可能不同，如有的使用-999标识空值。如果需要对这些非标准空值进行NaN替换，可以使用replace方法。可以替换单值：Df.replace( -999,np.NaN, inplace = True)或列表：Df.replace( [-999, -1000], np.NaN)或列表对：Df.replace( [-999, -1000], [np.NaN,0])或字典：Df.replace( {-999: np.NaN, -1000:0})。df的iloc方法，可以接收行号和列号进行选取。如果df.iloc[3][4]表示第三行，第四列。如果使用loc方法，则需要使用行号和列名，如df.loc[3][“A”]。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2、Matplotlib展示数据\n",
    "## 2.1 使用plot函数绘制曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%pylab inline\n",
    "\n",
    "x=range(10)\n",
    "y=[k**2 for k in x]\n",
    "plt.plot(x,y)\n",
    "plt.savefig(\"example1.jpg\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib用于在python环境下进行Matlab风格的绘图，使用时主要使用其接口库pyplot，使用前先导入：import matplotlib.pyplot as plt。普通的曲线使用plot函数即可完成，plot函数的参数角度。但大多有默认参数。只需要输入x和y轴的数据即可绘制出一条默认风格曲线图。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 使用控制字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x=range(10)\n",
    "y=[k**2 for k in x]\n",
    "plt.plot(x,y,'ro--')\n",
    "plt.savefig(\"example2.jpg\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "控制字符依次包括：颜色字符、风格字符和标记字符。其中，颜色字符：r、g、b等，或 数字格式'#008080'；风格字符：- 、-- 、-.、 |（实线、虚线、点画线等）；标记字符：.、,、v、<、>等；也可以使用显式表达，如color=“g”，linestyle=“dashed”，marker =“o”等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 图形中的文本"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x=range(10)\n",
    "y=[k**2 for k in x]\n",
    "plt.plot(x,y,'ro--',label=\"Sample\")\n",
    "plt.title(\"image show\",fontproperties=\"SimHei\",fontsize=20)\n",
    "plt.text(4,30,\"see here\",fontproperties=\"SimHei\",fontsize=20)\n",
    "plt.xlabel(\"X label\",fontproperties=\"SimHei\",fontsize=18)\n",
    "plt.ylabel(\"Y label\",fontproperties=\"SimHei\",fontsize=18)\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.savefig(\"example3.jpg\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在Matplotlib中有丰富的图形文本设置，如：设置标题title()，图例标注label，X轴标注xlabel()，Y轴标：ylabel()，文本信息text()等。默认情况下，不能显示汉字，如果需要显示汉字，可设置fontproperties参数，指定使用的字体即可。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 多线绘制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "x=np.arange(10)\n",
    "plt.plot(x,x,\"b|-\",x,x*2,\"go--\", x,x*3,\"r<-.\")\n",
    "plt.savefig(\"example4.jpg\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过查看plot的函数原型，可以发现：plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)，其中x轴数据可省略，而y轴数据不可省略。如果不设定多线的格式控制，系统自动区分。除了设置多个y轴数据，plot函数还可以直接接受多维数组。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 多子图绘制1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "plt.subplot(2,2,1)\n",
    "plt.plot(pd.DataFrame(np.arange(12).reshape((3,4))))\n",
    "plt.subplot(2,2,4)\n",
    "plt.plot(pd.Series(list(\"12725\")))\n",
    "plt.savefig(\"example5.jpg\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用subplot函数，可以把多个子图绘制在一起。其原型为：plt.subplot(rows, cols, number)，需要指定行列和当前正在绘制的编号，编号从左到右，从上到下，行优先。如plt.subplot(2,2,1)表示绘制2行2列的多子图，当前绘制位置是第1，subplot(2,2,4)则表示第四个位置（从上到下，都左到右）。\n",
    "\n",
    "## 2.6 多子图绘制2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "t=np.arange(0.0,2.0,0.1)\n",
    "s=np.sin(t*np.pi)\n",
    "figure,ax=plt.subplots(2,2)\n",
    "ax[0][0].plot(t,s,\"r*\")\n",
    "ax[1][1].plot(t*2,s,\"b--\")\n",
    "plt.savefig(\"example6.jpg\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "subplots函数可以生成一个画布和多个子图。其原型为：fig，ax = subplots(nrows, ncols, sharex, sharey, squeeze, subplot_kw, gridspec_kw, **fig_kw) 。　nrows和ncols表示将画布分割成几行几列 例：nrows = 2,ncols = 2表示将画布分割为2行2列，并起始值都为0，当调用画布中的坐标轴时，ax[0,0]表示调用坐上角的，ax[1,1]表示调用右下角的；sharex和sharey表示坐标轴的属性是否相同，可选的参数：True，False，row，col，默认值均为False，表示画布中的四个ax是相互独立的；当sharex = True, sharey = True时，生成的四个ax的所有坐标轴用有相同的属性;简单起见，直接使用二维索引的方式来获得指定的子图，并直接使用子图的plot方法进行绘制，如ax[0][0].plot(…)，在一个2行2列的画布上的第一个子图中绘制。\n",
    "\n",
    "## 2.7 不同的绘图风格"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "labels=\"A\",\"B\",\"C\",\"D\"\n",
    "fracs= [15,30.6,44.4,10]\n",
    "explode = [0,0.1,0,0]\n",
    "plt.axes(aspect=1)\n",
    "plt.pie(x=fracs,labels=labels,explode=explode,\n",
    "        autopct=\"%3.1f%%\",shadow=True,startangle=90)\n",
    "plt.savefig(\"example7.jpg\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pie函数用于绘制饼图。饼图常用的设置属性包括：x，(每一块)的比例，如果sum(x) > 1会使用sum(x)归一化；labels :(每一块)饼图外侧显示的说明文字；\n",
    "explode :(每一块)离开中心距离；startangle :起始绘制角度,默认图是从x轴正方向逆时针画起,如设定=90则从y轴正方向画起；shadow :在饼图下面画一个阴影。默认值：False，即不画阴影；labeldistance :label标记的绘制位置,相对于半径的比例，默认值为1.1, 如<1则绘制在饼图内侧；autopct :控制饼图内百分比设置,可以使用format字符串或者format function'%1.1f'指小数点前后位数(没有用空格补齐)。其他设置参数，请参阅使用手册。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
